/**
 * Spaces 相关的 TanStack Query Hooks
 * 提供空间数据的查询、创建、更新、删除功能
 */
import {useQuery, useMutation, useQueryClient} from '@tanstack/react-query';
import {QueryKeys} from '@/lib/queryClient';
import * as spacesApi from '@/api/spaces';
import {CreateSpaceRequest, UpdateSpaceRequest, SpaceDto} from '@/api/types';
import {useToast} from '@/hooks/ui/useToast';

/**
 * 获取所有空间列表
 * @returns Query 对象，包含 data、isLoading、error 等状态
 */
export function useSpaces() {
    return useQuery({
        queryKey: QueryKeys.spaces,
        queryFn: spacesApi.getSpaces,
        refetchOnWindowFocus: false,
        refetchOnReconnect: false,
    });
}

/**
 * 获取单个空间详情
 * @param spaceId - 空间 ID
 * @returns Query 对象，包含 data、isLoading、error 等状态
 */
export function useSpace(spaceId: number | null) {
    return useQuery({
        queryKey: spaceId ? QueryKeys.space(spaceId) : ['spaces', 'null'],
        queryFn: () => {
            if (!spaceId) {
                throw new Error('空间 ID 不能为空');
            }
            return spacesApi.getSpace(spaceId);
        },
        enabled: !!spaceId, // 仅当 spaceId 存在时才执行查询
    });
}

/**
 * 创建新空间（带乐观更新）
 * @returns Mutation 对象，包含 mutate、mutateAsync、isLoading 等方法和状态
 */
export function useCreateSpace() {
    const queryClient = useQueryClient();
    const {success, error} = useToast();

    return useMutation({
        mutationFn: spacesApi.createSpace,
        onMutate: async (newSpace: CreateSpaceRequest) => {
            // 取消正在进行的查询，避免冲突
            await queryClient.cancelQueries({queryKey: QueryKeys.spaces});

            // 保存当前缓存数据（用于回滚）
            const previousSpaces = queryClient.getQueryData<SpaceDto[]>(QueryKeys.spaces);

            // 乐观更新：立即添加临时数据
            const optimisticSpace: SpaceDto = {
                id: Date.now(), // 临时 ID
                name: newSpace.name,
                icon: newSpace.icon,
                icon_color: newSpace.icon_color,
                position: newSpace.position ?? 0,
                owner_id: 0,
                created_at: new Date().toISOString(),
                updated_at: new Date().toISOString(),
            };

            queryClient.setQueryData<SpaceDto[]>(
                QueryKeys.spaces,
                (old) => [...(old || []), optimisticSpace]
            );

            return {previousSpaces};
        },
        onSuccess: () => {
            // 成功后刷新缓存
            queryClient.invalidateQueries({queryKey: QueryKeys.spaces});
            success('空间创建成功');
        },
        onError: (_err, _newSpace, context) => {
            // 失败时回滚到之前的数据
            if (context?.previousSpaces) {
                queryClient.setQueryData(QueryKeys.spaces, context.previousSpaces);
            }
            error('空间创建失败');
        },
    });
}

/**
 * 更新空间（带乐观更新）
 * @returns Mutation 对象
 */
export function useUpdateSpace() {
    const queryClient = useQueryClient();
    const {success, error} = useToast();

    return useMutation({
        mutationFn: ({spaceId, data}: { spaceId: number; data: UpdateSpaceRequest }) =>
            spacesApi.updateSpace(spaceId, data),
        onMutate: async ({spaceId, data}) => {
            await queryClient.cancelQueries({queryKey: QueryKeys.spaces});
            const previousSpaces = queryClient.getQueryData<SpaceDto[]>(QueryKeys.spaces);

            // 乐观更新：立即修改本地数据
            queryClient.setQueryData<SpaceDto[]>(QueryKeys.spaces, (old) =>
                (old || []).map((space) =>
                    space.id === spaceId
                        ? {...space, ...data, updated_at: new Date().toISOString()}
                        : space
                )
            );

            return {previousSpaces};
        },
        onSuccess: () => {
            queryClient.invalidateQueries({queryKey: QueryKeys.spaces});
            success('空间更新成功');
        },
        onError: (_err, _variables, context) => {
            if (context?.previousSpaces) {
                queryClient.setQueryData(QueryKeys.spaces, context.previousSpaces);
            }
            error('空间更新失败');
        },
    });
}

/**
 * 删除空间
 * @returns Mutation 对象
 */
export function useDeleteSpace() {
    const queryClient = useQueryClient();
    const {success, error} = useToast();

    return useMutation({
        mutationFn: spacesApi.deleteSpace,
        onSuccess: () => {
            queryClient.invalidateQueries({queryKey: QueryKeys.spaces});
            success('空间删除成功');
        },
        onError: () => {
            error('空间删除失败');
        },
    });
}

/**
 * 重排序工作区
 * 组件层已做同步乐观更新和失败回滚，Hook 只负责：
 * - onSuccess: 合并后端返回的最新数据（updated_at 等）
 * @returns Mutation 对象
 */
export function useReorderSpaces() {
    const queryClient = useQueryClient();

    return useMutation({
        mutationFn: spacesApi.reorderSpaces,
        onSuccess: (updatedSpaces) => {
            // 合并后端返回的最新数据（含 updated_at 等服务端字段）
            if (updatedSpaces && updatedSpaces.length > 0) {
                queryClient.setQueryData<SpaceDto[]>(QueryKeys.spaces, (old) => {
                    if (!old) return old;

                    const updatedMap = new Map(updatedSpaces.map(s => [s.id, s]));

                    return old.map(space => {
                        const updated = updatedMap.get(space.id);
                        return updated || space;
                    }).sort((a, b) => a.position - b.position);
                });
            }
        },
    });
}
